package rexsee.natives;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Rect;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.view.MotionEvent;
import android.view.SoundEffectConstants;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewGroup;
import android.view.accessibility.AccessibilityEvent;
import android.widget.FrameLayout;
import android.widget.Toast;

public class SlidingDrawer extends ViewGroup {

	public static final int ORIENTATION_HORIZONTAL = 0;
	public static final int ORIENTATION_VERTICAL = 1;

	private static final int TAP_THRESHOLD = 6;
	private static final float MAXIMUM_TAP_VELOCITY = 100.0f;
	private static final float MAXIMUM_MINOR_VELOCITY = 150.0f;
	private static final float MAXIMUM_MAJOR_VELOCITY = 200.0f;
	private static final float MAXIMUM_ACCELERATION = 2000.0f;
	private static final int VELOCITY_UNITS = 1000;
	private static final int MSG_ANIMATE = 1000;
	private static final int ANIMATION_FRAME_DURATION = 1000 / 60;

	private static final int EXPANDED_FULL_OPEN = -10001;
	private static final int COLLAPSED_FULL_CLOSED = -10002;

	private final FrameLayout mHandle;
	private final FrameLayout mContent;

	private final Rect mFrame = new Rect();
	private final Rect mInvalidate = new Rect();
	private boolean mTracking;
	private boolean mLocked;

	private VelocityTracker mVelocityTracker;

	private boolean mExpanded;
	private int mHandleHeight;
	private int mHandleWidth;

	private OnDrawerOpenListener mOnDrawerOpenListener;
	private OnDrawerCloseListener mOnDrawerCloseListener;
	private OnDrawerScrollListener mOnDrawerScrollListener;

	private final Handler mHandler = new SlidingHandler();
	private float mAnimatedAcceleration;
	private float mAnimatedVelocity;
	private float mAnimationPosition;
	private long mAnimationLastTime;
	private long mCurrentAnimationTime;
	private int mTouchDelta;
	private boolean mAnimating;

	private final int mTapThreshold;
	private final int mMaximumTapVelocity;
	private final int mMaximumMinorVelocity;
	private final int mMaximumMajorVelocity;
	private final int mMaximumAcceleration;
	private final int mVelocityUnits;

	private final boolean mVertical;
	private final int mBottomOffset;
	private final int mTopOffset;
	private final boolean mAllowSingleTap;
	private final boolean mAnimateOnClick;

	public SlidingDrawer(Context context, boolean vertical) {

		super(context);

		mVertical = vertical;
		mBottomOffset = 0;
		mTopOffset = 0;
		mAllowSingleTap = true;
		mAnimateOnClick = true;

		final float density = getResources().getDisplayMetrics().density;
		mTapThreshold = (int) (TAP_THRESHOLD * density + 0.5f);
		mMaximumTapVelocity = (int) (MAXIMUM_TAP_VELOCITY * density + 0.5f);
		mMaximumMinorVelocity = (int) (MAXIMUM_MINOR_VELOCITY * density + 0.5f);
		mMaximumMajorVelocity = (int) (MAXIMUM_MAJOR_VELOCITY * density + 0.5f);
		mMaximumAcceleration = (int) (MAXIMUM_ACCELERATION * density + 0.5f);
		mVelocityUnits = (int) (VELOCITY_UNITS * density + 0.5f);

		setAlwaysDrawnWithCacheEnabled(false);

		mHandle = new FrameLayout(context);
		mHandle.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT));
		mHandle.setBackgroundColor(Color.TRANSPARENT);
		mContent = new FrameLayout(context);
		mContent.setLayoutParams(new FrameLayout.LayoutParams(FrameLayout.LayoutParams.FILL_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT));
		mContent.setBackgroundColor(Color.TRANSPARENT);
		addView(mHandle);
		addView(mContent);
		mHandle.setOnClickListener(new DrawerToggler());
		mContent.setVisibility(View.GONE);

	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
		int widthSpecSize = MeasureSpec.getSize(widthMeasureSpec);
		int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
		int heightSpecSize = MeasureSpec.getSize(heightMeasureSpec);
		if (widthSpecMode == MeasureSpec.UNSPECIFIED || heightSpecMode == MeasureSpec.UNSPECIFIED) { throw new RuntimeException("SlidingDrawer cannot have UNSPECIFIED dimensions"); }
		final View handle = mHandle;
		measureChild(handle, widthMeasureSpec, heightMeasureSpec);
		if (mVertical) {
			int height = heightSpecSize - handle.getMeasuredHeight() - mTopOffset;
			mContent.measure(MeasureSpec.makeMeasureSpec(widthSpecSize, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
		} else {
			int width = widthSpecSize - handle.getMeasuredWidth() - mTopOffset;
			mContent.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(heightSpecSize, MeasureSpec.EXACTLY));
		}
		setMeasuredDimension(widthSpecSize, heightSpecSize);
	}
	@Override
	protected void dispatchDraw(Canvas canvas) {
		final long drawingTime = getDrawingTime();
		final View handle = mHandle;
		final boolean isVertical = mVertical;
		drawChild(canvas, handle, drawingTime);
		if (mTracking || mAnimating) {
			final Bitmap cache = mContent.getDrawingCache();
			if (cache != null) {
				if (isVertical) {
					canvas.drawBitmap(cache, 0, handle.getBottom(), null);
				} else {
					canvas.drawBitmap(cache, handle.getRight(), 0, null);
				}
			} else {
				canvas.save();
				canvas.translate(isVertical ? 0 : handle.getLeft() - mTopOffset, isVertical ? handle.getTop() - mTopOffset : 0);
				drawChild(canvas, mContent, drawingTime);
				canvas.restore();
			}
		} else if (mExpanded) {
			drawChild(canvas, mContent, drawingTime);
		}
	}
	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
		if (mTracking) { return; }
		final int width = r - l;
		final int height = b - t;
		final View handle = mHandle;
		int childWidth = handle.getMeasuredWidth();
		int childHeight = handle.getMeasuredHeight();
		int childLeft;
		int childTop;
		final View content = mContent;
		if (mVertical) {
			childLeft = (width - childWidth) / 2;
			childTop = mExpanded ? mTopOffset : height - childHeight + mBottomOffset;
			content.layout(0, mTopOffset + childHeight, content.getMeasuredWidth(), mTopOffset + childHeight + content.getMeasuredHeight());
		} else {
			childLeft = mExpanded ? mTopOffset : width - childWidth + mBottomOffset;
			childTop = (height - childHeight) / 2;
			content.layout(mTopOffset + childWidth, 0, mTopOffset + childWidth + content.getMeasuredWidth(), content.getMeasuredHeight());
		}
		handle.layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight);
		mHandleHeight = handle.getHeight();
		mHandleWidth = handle.getWidth();
	}
	@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		if (mLocked) { return false; }
		final int action = event.getAction();
		float x = event.getX();
		float y = event.getY();
		final Rect frame = mFrame;
		final View handle = mHandle;
		handle.getHitRect(frame);
		if (!mTracking && !frame.contains((int) x, (int) y)) { return false; }
		if (action == MotionEvent.ACTION_DOWN) {
			mTracking = true;
			handle.setPressed(true);
			// Must be called before prepareTracking()
			prepareContent();
			// Must be called after prepareContent()
			if (mOnDrawerScrollListener != null) {
				mOnDrawerScrollListener.onScrollStarted();
			}
			if (mVertical) {
				final int top = mHandle.getTop();
				mTouchDelta = (int) y - top;
				prepareTracking(top);
			} else {
				final int left = mHandle.getLeft();
				mTouchDelta = (int) x - left;
				prepareTracking(left);
			}
			mVelocityTracker.addMovement(event);
		}
		return true;
	}
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (mLocked) { return true; }

		if (mTracking) {
			mVelocityTracker.addMovement(event);
			final int action = event.getAction();
			switch (action) {
				case MotionEvent.ACTION_MOVE :
					moveHandle((int) (mVertical ? event.getY() : event.getX()) - mTouchDelta);
					break;
				case MotionEvent.ACTION_UP :
				case MotionEvent.ACTION_CANCEL :
					try {
						final VelocityTracker velocityTracker = mVelocityTracker;
						velocityTracker.computeCurrentVelocity(mVelocityUnits);

						float yVelocity = velocityTracker.getYVelocity();
						float xVelocity = velocityTracker.getXVelocity();
						boolean negative;

						final boolean vertical = mVertical;
						if (vertical) {
							negative = yVelocity < 0;
							if (xVelocity < 0) {
								xVelocity = -xVelocity;
							}
							if (xVelocity > mMaximumMinorVelocity) {
								xVelocity = mMaximumMinorVelocity;
							}
						} else {
							negative = xVelocity < 0;
							if (yVelocity < 0) {
								yVelocity = -yVelocity;
							}
							if (yVelocity > mMaximumMinorVelocity) {
								yVelocity = mMaximumMinorVelocity;
							}
						}

						float velocity = (float) Math.hypot(xVelocity, yVelocity);
						if (negative) {
							velocity = -velocity;
						}

						final int top = mHandle.getTop();
						final int left = mHandle.getLeft();

						if (Math.abs(velocity) < mMaximumTapVelocity) {
							if (vertical ? (mExpanded && top < mTapThreshold + mTopOffset) ||
									(!mExpanded && top > mBottomOffset + getBottom() - getTop() -
											mHandleHeight - mTapThreshold) :
									(mExpanded && left < mTapThreshold + mTopOffset) ||
											(!mExpanded && left > mBottomOffset + getRight() - getLeft() -
													mHandleWidth - mTapThreshold)) {

								if (mAllowSingleTap) {
									playSoundEffect(SoundEffectConstants.CLICK);

									if (mExpanded) {
										animateClose(vertical ? top : left);
									} else {
										animateOpen(vertical ? top : left);
									}
								} else {
									performFling(vertical ? top : left, velocity, false);
								}

							} else {
								performFling(vertical ? top : left, velocity, false);
							}
						} else {
							performFling(vertical ? top : left, velocity, false);
						}
					} catch (Exception e) {
						Toast.makeText(this.getContext(), this.getClass().getSimpleName() + ":" + e.getLocalizedMessage(), Toast.LENGTH_LONG).show();
					}
					break;
				default :
					break;
			}
		}

		return mTracking || mAnimating || super.onTouchEvent(event);
	}

	private void animateClose(int position) {
		prepareTracking(position);
		performFling(position, mMaximumAcceleration, true);
	}
	private void animateOpen(int position) {
		prepareTracking(position);
		performFling(position, -mMaximumAcceleration, true);
	}
	private void performFling(int position, float velocity, boolean always) {
		mAnimationPosition = position;
		mAnimatedVelocity = velocity;
		if (mExpanded) {
			if (always || (velocity > mMaximumMajorVelocity || (position > mTopOffset + (mVertical ? mHandleHeight : mHandleWidth) && velocity > -mMaximumMajorVelocity))) {
				// We are expanded, but they didn't move sufficiently to cause us to retract.  Animate back to the expanded position.
				mAnimatedAcceleration = mMaximumAcceleration;
				if (velocity < 0) mAnimatedVelocity = 0;
			} else {
				// We are expanded and are now going to animate away.
				mAnimatedAcceleration = -mMaximumAcceleration;
				if (velocity > 0) mAnimatedVelocity = 0;
			}
		} else {
			if (!always && (velocity > mMaximumMajorVelocity || (position > (mVertical ? getHeight() : getWidth()) / 2 && velocity > -mMaximumMajorVelocity))) {
				// We are collapsed, and they moved enough to allow us to expand.
				mAnimatedAcceleration = mMaximumAcceleration;
				if (velocity < 0) mAnimatedVelocity = 0;
			} else {
				// We are collapsed, but they didn't move sufficiently to cause us to retract.  Animate back to the collapsed position.
				mAnimatedAcceleration = -mMaximumAcceleration;
				if (velocity > 0) mAnimatedVelocity = 0;
			}
		}
		long now = SystemClock.uptimeMillis();
		mAnimationLastTime = now;
		mCurrentAnimationTime = now + ANIMATION_FRAME_DURATION;
		mAnimating = true;
		mHandler.removeMessages(MSG_ANIMATE);
		mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE), mCurrentAnimationTime);
		stopTracking();
	}
	private void prepareTracking(int position) {
		mTracking = true;
		mVelocityTracker = VelocityTracker.obtain();
		boolean opening = !mExpanded;
		if (opening) {
			mAnimatedAcceleration = mMaximumAcceleration;
			mAnimatedVelocity = mMaximumMajorVelocity;
			mAnimationPosition = mBottomOffset + (mVertical ? getHeight() - mHandleHeight : getWidth() - mHandleWidth);
			moveHandle((int) mAnimationPosition);
			mAnimating = true;
			mHandler.removeMessages(MSG_ANIMATE);
			long now = SystemClock.uptimeMillis();
			mAnimationLastTime = now;
			mCurrentAnimationTime = now + ANIMATION_FRAME_DURATION;
			mAnimating = true;
		} else {
			if (mAnimating) {
				mAnimating = false;
				mHandler.removeMessages(MSG_ANIMATE);
			}
			moveHandle(position);
		}
	}
	private void moveHandle(int position) {
		final View handle = mHandle;
		if (mVertical) {
			if (position == EXPANDED_FULL_OPEN) {
				handle.offsetTopAndBottom(mTopOffset - handle.getTop());
				invalidate();
			} else if (position == COLLAPSED_FULL_CLOSED) {
				handle.offsetTopAndBottom(mBottomOffset + getBottom() - getTop() - mHandleHeight - handle.getTop());
				invalidate();
			} else {
				final int top = handle.getTop();
				int deltaY = position - top;
				if (position < mTopOffset) {
					deltaY = mTopOffset - top;
				} else if (deltaY > mBottomOffset + getBottom() - getTop() - mHandleHeight - top) {
					deltaY = mBottomOffset + getBottom() - getTop() - mHandleHeight - top;
				}
				handle.offsetTopAndBottom(deltaY);
				final Rect frame = mFrame;
				final Rect region = mInvalidate;
				handle.getHitRect(frame);
				region.set(frame);
				region.union(frame.left, frame.top - deltaY, frame.right, frame.bottom - deltaY);
				region.union(0, frame.bottom - deltaY, getWidth(), frame.bottom - deltaY + mContent.getHeight());
				invalidate(region);
			}
		} else {
			if (position == EXPANDED_FULL_OPEN) {
				handle.offsetLeftAndRight(mTopOffset - handle.getLeft());
				invalidate();
			} else if (position == COLLAPSED_FULL_CLOSED) {
				handle.offsetLeftAndRight(mBottomOffset + getRight() - getLeft() -
						mHandleWidth - handle.getLeft());
				invalidate();
			} else {
				final int left = handle.getLeft();
				int deltaX = position - left;
				if (position < mTopOffset) {
					deltaX = mTopOffset - left;
				} else if (deltaX > mBottomOffset + getRight() - getLeft() - mHandleWidth - left) {
					deltaX = mBottomOffset + getRight() - getLeft() - mHandleWidth - left;
				}
				handle.offsetLeftAndRight(deltaX);
				final Rect frame = mFrame;
				final Rect region = mInvalidate;
				handle.getHitRect(frame);
				region.set(frame);
				region.union(frame.left - deltaX, frame.top, frame.right - deltaX, frame.bottom);
				region.union(frame.right - deltaX, 0, frame.right - deltaX + mContent.getWidth(), getHeight());
				invalidate(region);
			}
		}
	}
	private void prepareContent() {
		if (mAnimating) return;
		// Something changed in the content, we need to honor the layout request before creating the cached bitmap
		final View content = mContent;
		if (content.isLayoutRequested()) {
			if (mVertical) {
				final int childHeight = mHandleHeight;
				int height = getBottom() - getTop() - childHeight - mTopOffset;
				content.measure(MeasureSpec.makeMeasureSpec(getRight() - getLeft(), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
				content.layout(0, mTopOffset + childHeight, content.getMeasuredWidth(), mTopOffset + childHeight + content.getMeasuredHeight());
			} else {
				final int childWidth = mHandle.getWidth();
				int width = getRight() - getLeft() - childWidth - mTopOffset;
				content.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(getBottom() - getTop(), MeasureSpec.EXACTLY));
				content.layout(childWidth + mTopOffset, 0, mTopOffset + childWidth + content.getMeasuredWidth(), content.getMeasuredHeight());
			}
		}
		// Try only once... we should really loop but it's not a big deal if the draw was cancelled, it will only be temporary anyway
		content.getViewTreeObserver().dispatchOnPreDraw();
		content.buildDrawingCache();
		content.setVisibility(View.GONE);
	}
	private void stopTracking() {
		mHandle.setPressed(false);
		mTracking = false;
		if (mOnDrawerScrollListener != null) {
			mOnDrawerScrollListener.onScrollEnded();
		}
		if (mVelocityTracker != null) {
			mVelocityTracker.recycle();
			mVelocityTracker = null;
		}
	}
	private void closeDrawer() {
		moveHandle(COLLAPSED_FULL_CLOSED);
		mContent.setVisibility(View.GONE);
		mContent.destroyDrawingCache();
		if (!mExpanded) return;
		mExpanded = false;
		if (mOnDrawerCloseListener != null) mOnDrawerCloseListener.onDrawerClosed();
	}
	private void openDrawer() {
		moveHandle(EXPANDED_FULL_OPEN);
		mContent.setVisibility(View.VISIBLE);
		if (mExpanded) return;
		mExpanded = true;
		if (mOnDrawerOpenListener != null) mOnDrawerOpenListener.onDrawerOpened();
	}

	public void toggle() {
		if (!mExpanded) {
			openDrawer();
		} else {
			closeDrawer();
		}
		invalidate();
		requestLayout();
	}
	public void animateToggle() {
		if (!mExpanded) {
			animateOpen();
		} else {
			animateClose();
		}
	}
	public void open() {
		openDrawer();
		invalidate();
		requestLayout();
		sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
	}
	public void close() {
		closeDrawer();
		invalidate();
		requestLayout();
	}
	public void animateClose() {
		prepareContent();
		final OnDrawerScrollListener scrollListener = mOnDrawerScrollListener;
		if (scrollListener != null) scrollListener.onScrollStarted();
		animateClose(mVertical ? mHandle.getTop() : mHandle.getLeft());
		if (scrollListener != null) scrollListener.onScrollEnded();
	}
	public void animateOpen() {
		prepareContent();
		final OnDrawerScrollListener scrollListener = mOnDrawerScrollListener;
		if (scrollListener != null) scrollListener.onScrollStarted();
		animateOpen(mVertical ? mHandle.getTop() : mHandle.getLeft());
		sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED);
		if (scrollListener != null) scrollListener.onScrollEnded();
	}
	public void setOnDrawerOpenListener(OnDrawerOpenListener onDrawerOpenListener) {
		mOnDrawerOpenListener = onDrawerOpenListener;
	}
	public void setOnDrawerCloseListener(OnDrawerCloseListener onDrawerCloseListener) {
		mOnDrawerCloseListener = onDrawerCloseListener;
	}
	public void setOnDrawerScrollListener(OnDrawerScrollListener onDrawerScrollListener) {
		mOnDrawerScrollListener = onDrawerScrollListener;
	}
	public FrameLayout getHandle() {
		return mHandle;
	}
	public FrameLayout getContent() {
		return mContent;
	}
	public void unlock() {
		mLocked = false;
	}
	public void lock() {
		mLocked = true;
	}
	public boolean isOpened() {
		return mExpanded;
	}
	public boolean isMoving() {
		return mTracking || mAnimating;
	}

	private class DrawerToggler implements OnClickListener {
		@Override
		public void onClick(View v) {
			if (mLocked) return;
			if (mAnimateOnClick) {
				animateToggle();
			} else {
				toggle();
			}
		}
	}
	private class SlidingHandler extends Handler {
		@Override
		public void handleMessage(Message m) {
			switch (m.what) {
				case MSG_ANIMATE :
					if (mAnimating) {
						((Activity) SlidingDrawer.this.getContext()).runOnUiThread(new Runnable() {
							@Override
							public void run() {
								long now = SystemClock.uptimeMillis();
								float t = (now - mAnimationLastTime) / 1000.0f; // ms -> s
								final float position = mAnimationPosition;
								final float v = mAnimatedVelocity; // px/s
								final float a = mAnimatedAcceleration; // px/s/s
								mAnimationPosition = position + (v * t) + (0.5f * a * t * t); // px
								mAnimatedVelocity = v + (a * t); // px/s
								mAnimationLastTime = now; // ms
								if (mAnimationPosition >= mBottomOffset + (mVertical ? getHeight() : getWidth()) - 1) {
									mAnimating = false;
									closeDrawer();
								} else if (mAnimationPosition < mTopOffset) {
									mAnimating = false;
									openDrawer();
								} else {
									moveHandle((int) mAnimationPosition);
									mCurrentAnimationTime += ANIMATION_FRAME_DURATION;
									mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE), mCurrentAnimationTime);
								}
							}
						});
					}
					break;
			}
		}
	}

	public static interface OnDrawerOpenListener {
		public void onDrawerOpened();
	}
	public static interface OnDrawerCloseListener {
		public void onDrawerClosed();
	}
	public static interface OnDrawerScrollListener {
		public void onScrollStarted();
		public void onScrollEnded();
	}

}
